package com.atguigu.demo;

import com.oracle.xmlns.internal.webservices.jaxws_databinding.JavaMethod;

/**
 * @ClassName SparseArrayTest
 * @DeScription SparseArrayTest
 * @Author 剧情再美终是戏
 * @Date 2019/11/18 18:51
 * @Version 1.0
 **/
public class SparseArrayTest {

    private static final int RECTANGLE_NO = 11;


    public static void main(String[] args) {
        // 初始化一个二维数组的集合（并在第二行第三列，第三行第四列初始化为1）
        int[][] arrays = new int[RECTANGLE_NO][RECTANGLE_NO];
        arrays[1][2] = 1;
        arrays[2][3] = 1;

        // 输出这个数组
        System.out.println("-------------------两维数组输出----------------------");
        prinInfo(arrays);

        // 将二级数级转换为稀疏二维数组,将输出
        int[][] sparseArrays = parseSparseArray(arrays);
        System.out.println("-------------------两维数组输-->稀疏二维数组----------------------");
        prinInfo(sparseArrays);

        // 将稀疏二维数组转换为二维数组，并输出
        int[][] arraysParse = parseArray(sparseArrays);
        System.out.println("-------------------稀疏二维数组-->两维数组输出-parse----------------------");
        prinInfo(arraysParse);
    }

    /**
     * 将稀疏二维数组转换为二维数组
     *
     * @param sparseArrays 二维稀疏数组
     * @return int[][] 二维数组
     * @Author 剧情再美终是戏
     * @Date 2019/11/18
     * @Version 1.0
     **/
    public static int[][] parseArray(int[][] sparseArrays) {
        int[][] arrays = new int[sparseArrays[0][0]][sparseArrays[0][1]];
        for (int i = 1; i < sparseArrays.length; i++) {
            arrays[sparseArrays[i][0]][sparseArrays[i][1]] = sparseArrays[i][2];
        }
        return arrays;
    }


    /**
     * 将二级数级转换为稀疏二维数组
     *
     * @param arrays 二维数组
     * @return int[][] 稀疏二维数组
     * @Author 剧情再美终是戏
     * @Date 2019/11/18
     * @Version 1.0
     **/
    public static int[][] parseSparseArray(int[][] arrays) {
        // 计算非0个数，进行构建稀疏二维数组
        int ne0Total = calculationArraysNE0(arrays, 0);

        // 组装值
        int[][] sparseArrays = new int[ne0Total + 1][3];
        sparseArrays[0][0] = RECTANGLE_NO;
        sparseArrays[0][1] = RECTANGLE_NO;
        sparseArrays[0][2] = ne0Total;
        int index = 1;
        for (int i = 0; i < arrays.length; i++) {
            int[] param = arrays[i];
            for (int j = 0; j < param.length; j++) {
                int p = param[j];
                if (0 != p) {
                    sparseArrays[index][0] = i;
                    sparseArrays[index][1] = j;
                    sparseArrays[index][2] = p;
                    index++;
                }
            }
        }
        return sparseArrays;
    }


    /**
     * 输出集合
     *
     * @param params
     * @return void
     * @Author 剧情再美终是戏
     * @Date 2019/11/18
     * @Version 1.0
     **/
    public static void prinInfo(int[][] params) {
        for (int i = 0; i < params.length; i++) {
            int[] param = params[i];
            for (int j = 0; j < param.length; j++) {
                System.out.printf("%d\t", params[i][j]);
            }
            System.out.println();
        }
    }

    /**
     * 计算一个数组中不等于某个值出现的个数
     *
     * @param params
     * @param compareNo
     * @return int
     * @Author 剧情再美终是戏
     * @Date 2019/11/18
     * @Version 1.0
     **/
    public static int calculationArraysNE0(int[][] params, int compareNo) {
        int total = 0;
        for (int[] param : params) {
            for (int p : param) {
                if (compareNo != p) {
                    total++;
                }
            }
        }
        return total;
    }
}
